import Vue from "vue"
import Vuex from "vuex"

//主题切换
// import theme from "./theme.js"
//主题仓库
import theme from "./themeStore.js"
import player from "./player.js"

//主页数据
import homePageConfigRaw from '@/common/homePageConfig.js'

import API from '@/common/apiUrl'
import {
	get
} from '@/common/api'
import {
	convertCount,
	pickUpName
} from '@/common/util'
import moment from 'moment'

Vue.use(Vuex)
const store = new Vuex.Store({
	state: {
		topListIds: [], //播放列表
		nextId: '', //下一首
	},
	getters: {
		/**
		 * 获取主页数据
		 */
		getHomePageConfig() {
			// 检查storage中有没有
			const homePageConfigStorage = uni.getStorageSync('homePageConfig')

			// 将要使用的主页数据
			let homePageConfig
			// 如果storage中有，则赋值。若storage中没有，直接使用原始数据
			if (!!homePageConfigStorage) {
				homePageConfig = homePageConfigStorage
			} else {
				homePageConfig = homePageConfigRaw
				uni.setStorageSync('homePageConfig', homePageConfigRaw)
			}

			return homePageConfig
		},

	},
	actions: {
		//滚动穿透
		setPageMetaOverflow(status) {
			this.overflow = status
		},

		// 获取首页数据 (可选登录)
		async getHomePage(context, offset) {
			const res = await get(API.GET_HOME_PAGE, {
				cursor: {
					offset
				},
				refresh: ''
			}, true, false)
			console.log("取得首页数据", res);
			const cursor = res?.data?.cursor ? JSON.parse(res.data.cursor) : ''
			return {
				offset: cursor.offset ? cursor.offset : 0,
				more: res.data.hasMore,
				data: res.data.blocks
			}
		},
		// 获取首页入口按钮数据 (可选登录)
		async getHomeBall() {
			const res = await get(API.GET_HOME_BALL, {}, true, false)
			// console.log("获取首页入口按钮数据",res);
			return res.data
		},

		/**
		 *  ↓ 歌单
		 */

		/**
		 * 收藏/取消收藏歌单 (登录)
		 * @param id 资源 id
		 * @param t 1收藏，2取消收藏
		 */
		async getSubscribe({},id, t) {
			const args = {
				id,
				t
			}
			return await get(API.PLAYLIST.GET_PLAYLIST_SUBSCRIBE, args, true, false)
		},

		// 歌单-获取所有歌单分类
		async getPlaylistCatlist() {
			return await get(API.PLAYLIST.GET_PLAYLIST_CATLIST, {})
		},

		// 歌单-今日推荐, 不支持offset
		async getRcmdPlaylist({},limit = 6) {
			const resJson = await get(API.PLAYLIST.GET_RECOMMENDS, {
				limit
			})
			const data = resJson.result.map((v) => {
				const playCount = convertCount(v.playCount) || 0
				return {
					payload: v.id,
					// 可能是专辑、歌单、数字专辑等
					type: 'list',
					// 播放数量
					playCount,
					// 标题
					title: v.name,
					// 小标题
					subTitle: '',
					// 封面链接
					picUrl: v.picUrl
				}
			})

			return {
				data,
				more: false
			}
		},

		// 歌单分类列表
		async getPlaylistTop({},{
			limit = 30,
			offset = 0,
			cat = '华语'
		}) {
			const resJson = await get(API.PLAYLIST.GET_PLAYLIST_TOP, {
				limit,
				offset,
				cat
			})
			const data = resJson.playlists.map((v) => {
				const playCount = convertCount(v.playCount) || 0
				return {
					payload: v.id,
					// 可能是专辑、歌单、数字专辑等
					type: 'list',
					// 播放数量
					playCount,
					// 标题
					title: v.name,
					// 小标题
					subTitle: '',
					// 封面链接
					picUrl: v.coverImgUrl
				}
			})
			return {
				data,
				total: resJson.total,
				more: data.length > 0,
				type: 'PlaylistTop'
			}
		},

		// 精品歌单 before 分页参数,取上一页最后一个歌单的 updateTime 获取下一页数据
		async getPlaylistHq({},{
			limit = 6,
			before = undefined
		}) {
			const args = {
				limit
			}
			if (before) args.before = before
			const resJson = await get(API.PLAYLIST.GET_PLAYLIST_HQ, args)

			const data = resJson.playlists.map((v) => {
				const playCount = convertCount(v.playCount) || 0
				return {
					payload: v.id,
					// 可能是专辑、歌单、数字专辑等
					type: 'list',
					// 播放数量
					playCount,
					// 标题
					title: v.name,
					// 小标题
					subTitle: '',
					// 封面链接
					picUrl: v.coverImgUrl
				}
			})
			return {
				data,
				total: resJson.total,
				more: data.length > 0,
				type: 'PlaylistHq',
				// 分页参数,取上一页最后一个歌单的 updateTime 获取下一页数据
				updateTime: resJson.lasttime
			}
		},

		// 获取网易云官方歌单，通过官方账号uid获取用户歌单
		async getOfficialPlaylist({},{
			limit = 30,
			offset = 0
		}) {
			const resJson = await get(API.USER.GET_USER_PLAYLIST, {
				uid: 1463586082,
				limit,
				offset
			})
			const data = resJson.playlist
				.map((v) => {
					const playCount = convertCount(v.playCount) || 0
					return {
						payload: v.id,
						// 可能是专辑、歌单、数字专辑等
						type: 'list',
						// 播放数量
						playCount,
						// 标题
						title: v.name,
						// 小标题
						subTitle: '',
						// 封面链接
						picUrl: v.coverImgUrl
					}
				})
				.slice(1)

			return {
				data,
				total: resJson.total,
				more: data.length > 0,
				type: 'OfficialPlaylist'
			}
		},

		// 获取歌单详情 (可选登录)
		async getPlaylistDetail({},id) {
			const data = await get(API.PLAYLIST.GET_PLAYLIST_DETAIL, {
				id
			}, true, true)

			if (data.code !== 200) {
				console.error(data)
				return undefined
			} else {
				return {
					payload: data.playlist.id,
					// 作者信息
					creator: {
						// 作者封面
						picUrl: data.playlist.creator.avatarUrl,
						// 作者名
						name: data.playlist.creator.nickname,
						// 作者id
						id: data.playlist.creator.userId
					},
					// 是否订阅了歌单
					subscribed: data.playlist.subscribed,
					// 歌曲数量
					trackCount: data.playlist.trackCount,
					// 订阅数量
					subscribedCount: convertCount(data.playlist.subscribedCount),
					// 播放数量
					playCount: convertCount(data.playlist.playCount),
					// 评论数量
					commentCount: convertCount(data.playlist.commentCount),
					// 分享数量
					shareCount: convertCount(data.playlist.shareCount),
					// 发布日期
					createTime: moment(data.playlist.createTime).format('YYYY年M月D日'),
					// 歌曲id集合
					trackIds: data.playlist.trackIds.map((v) => v.id),
					// 歌名
					title: data.playlist.name,
					// 歌曲描述
					desc: data.playlist.description,
					// 歌曲封面
					picUrl: data.playlist.coverImgUrl
				}
			}
		},

		// 所有榜单详情
		async getToplistDetail() {
			const resJson = await get(API.GET_TOPLIST_DETAIL, {})
			const data = resJson.list.map((item) => {
				return {
					payload: item.id,
					// 可能是专辑、歌单、数字专辑等
					type: 'list',
					// 播放数量
					playCount: item.updateFrequency,
					// 标题
					title: item.name,
					// 封面链接
					picUrl: item.coverImgUrl
				}
			})

			return data
		},

		//播放下一首功能
		// INIT_TOPLISTIDS(state, payload){
		// 	state.topListIds = payload
		// },
		// NEXT_ID(state, payload){
		// 	for(let i=0;i<state.topListIds.length;i++){
		// 		if(state.topListIds[i] == payload){
		// 			//获取到下一首的id
		// 			state.nextId= state.topListIds[i+1].id
		// 		}
		// 	}
		// },

		/**
		 * ↓ 单曲
		 */

		// 获取单曲详情
		async getSongsDetail({}, trackIds) {
			// 切割ids为100个一组 [ [...ids], [...ids], [...ids] ]
			const ids = JSON.parse(JSON.stringify(trackIds))

			function sliceArray(newArr, ids) {
				const newIds = ids
				if (ids.length > 100) {
					newArr.push(newIds.splice(0, 100))
					return sliceArray(newArr, newIds)
				} else {
					newArr.push(ids)
					return newArr
				}
			}

			return new Promise(resolve => {
				// 切割好的ids
				const idsChunks = sliceArray([], ids)

				// 发起所有请求
				const requestQueue = idsChunks.map(idsArr => {
					return get(API.SONG.GET_SONG_DETAIL, {
						ids: idsArr.toString()
					})
				})

				const result = []

				// 接收所有结果
				Promise.allSettled(requestQueue).then(resArr => {
					resArr.forEach(res => {
						if (res.status === 'fulfilled' && res.value.code === 200) {
							const data = res.value.songs.map((v) => {
								// 找到支持的最高音质
								const quality = ['sq', 'h', 'l', 'm']
								const maxQIdx = [!!v.sq, !!v.h, !!v.l, !!v
									.m
								].indexOf(true)
								// 译名
								const tns = v.tns

								return {
									// 最高音质
									maxQ: quality[maxQIdx],

									// id
									payload: v.id,

									// MV
									mv: v.mv === 0 ? null : v.mv,

									// 作者名
									artist: pickUpName(v.ar),

									ar: v.ar,

									// 创作者(多人)
									creator: pickUpName(v.ar),

									// 歌曲封面
									picUrl: v.al.picUrl,

									// 歌曲名
									title: tns ? `${v.name}（${tns}）` : v
										.name,

									// 来自专辑
									album: v.al.name,

									// 发布时间 年
									publishTime: v.publishTime ? moment(v
											.publishTime).year()
									.toString() : '',

									// 歌曲时长，单位分钟
									duration: v.dt,

									// 是否需要会员
									fee: v.fee.toString()
								}
							})
							result.push(...data)
						}
					})

					resolve(result)
				})
			})
		},

		// 获取单曲url
		async getSongUrl(id) {
			//参数必须为对象
			const resJson = await get(API.SONG.GET_SONG_URL, {
				id: '33894312'
			}) //{ id }
			console.log("获取单曲", resJson);
			if (!resJson.data[0].url) {
				uni.showToast({
					title: '似乎不能播放',
					duration: 2000,
					icon: 'none'
				})
				return undefined
			} else {
				return resJson.data[0].url
			}
		},

		/**
		 * 评论
		 */

		/**
		 * 获取歌单评论
		 * @param pageNo 分页参数,第 N 页,默认为 1
		 * @param pageSize 分页参数,每页多少条数据,默认 30
		 * @param sortType 排序方式, 1:按推荐排序, 2:按热度排序, 3:按时间排序
		 * @param cursor 当sortType为 3 时且页数不是第一页时需传入,值为上一条数据的 time
		 * @param type  类型  0:歌曲  1:mv 2:歌单 3:专辑 4:电台 5:视频 6:动态
		 *
		 */
		async getComment({},
			id = 0,
			pageNo = 1,
			pageSize = 100,
			sortType = 1,
			cursor = undefined,
			type
		) {
			const args = {
				id,
				pageNo,
				pageSize,
				sortType,
				type
			}
			if (cursor) args.cursor = cursor
			return await get(API.COMMENT.GET_COMMENT_NEW, args, true, true)
		},
		/**
		 * 点赞评论（登录）
		 * @param id 资源 id
		 * @param cid 评论id
		 * @param t 1点赞，0取消点赞
		 * @param type 数字 , 资源类型 , 对应歌曲 , mv, 专辑 , 歌单 , 电台, 视频对应以下类型
		 */
		async getCommentLike({},id, cid, t, type) {
			const args = {
				id,
				cid,
				t,
				type
			}
			return await get(API.COMMENT.GET_COMMENT_LIKE, args, true, false)
		},
		/**
		 * 楼层评论
		 * @param parentCommentId 楼层评论id
		 * @param id 资源id
		 * @param type 0: 歌曲 1: mv 2: 歌单 3: 专辑 4: 电台 5: 视频
		 */
		async getCommentFloor({},
			parentCommentId,
			id,
			pageNo = 1,
			pageSize = 100,
			sortType = 1,
			type,
			beforeTime
		) {
			const args = {
				id,
				parentCommentId,
				limit: pageSize,
				offset: (pageNo - 1) * pageSize,
				sortType,
				type,
				before: beforeTime
			}
			return await get(API.COMMENT.GET_COMMENT_FLOOR, args, false, false)
		}
	},
	modules: {
		theme,
		player
	}
})

export default store